//#include "glwidget.h"
//
//#include <QOpenGLShaderProgram>
//#include <QOpenGLTexture>
//#include <QMouseEvent>
//
//GLWidget::GLWidget(QWidget *parent)
//    : QOpenGLWidget(parent),
//        clearColour(Qt::black),
//        xRot(0),
//        yRot(0),
//        zRot(0),
//        program(0),
//        frame_texture(NULL),
//        v_aspect(1.0)
//{
//    hasTexture       = false;
//}
//
//GLWidget::~GLWidget()
//{
//    makeCurrent();
//
//    if(vbo.isCreated()) vbo.destroy();
//    if(hasTexture) delete frame_texture;
//
//    delete program;
//    doneCurrent();
//}
//
//void GLWidget::SetImage(const QImage &img)
//{
//    makeCurrent();
//
//    if(frame_texture) delete frame_texture;
//    frame_texture = new QOpenGLTexture(img);
//    hasTexture    = true;
//    v_aspect      = (float)(img.height())/img.width();
//
//    makeObject();
//    doneCurrent();
//    update();
//}
//
//QSize GLWidget::minimumSizeHint() const
//{
//    return(QSize(160, 90));
//}
//
//QSize GLWidget::sizeHint() const
//{
//    return(QSize(800, 450));
//}
//
//void GLWidget::rotateBy(int xAngle, int yAngle, int zAngle)
//{
//    xRot += xAngle;
//    yRot += yAngle;
//    zRot += zAngle;
//    update();
//}
//
//void GLWidget::setClearColor(const QColor &color)
//{
//    clearColour = color;
//    update();
//}
//
//// Run once when widget is set up
//void GLWidget::initializeGL()
//{
//    initializeOpenGLFunctions();
//
//    glEnable(GL_DEPTH_TEST);
//    // glEnable(GL_CULL_FACE);
//
//#define PROGRAM_VERTEX_ATTRIBUTE 0
//#define PROGRAM_TEXCOORD_ATTRIBUTE 1
//
//    QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
//    const char *vsrc =
//        "attribute highp vec4 vertex;\n"
//        "attribute mediump vec4 texCoord;\n"
//        "varying mediump vec4 texc;\n"
//        "uniform mediump mat4 matrix;\n"
//        "void main(void)\n"
//        "{\n"
//        "    gl_Position = matrix * vertex;\n"
//        "    texc = texCoord;\n"
//        "}\n";
//    vshader->compileSourceCode(vsrc);
//
//    QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
//    const char *fsrc =
//        "uniform sampler2D texture;\n"
//        "varying mediump vec4 texc;\n"
//        "void main(void)\n"
//        "{\n"
//        "    gl_FragColor = texture2D(texture, texc.st);\n"
//        "}\n";
//    fshader->compileSourceCode(fsrc);
//
//    program = new QOpenGLShaderProgram;
//    program->addShader(vshader);
//    program->addShader(fshader);
//    program->bindAttributeLocation("vertex", PROGRAM_VERTEX_ATTRIBUTE);
//    program->bindAttributeLocation("texCoord", PROGRAM_TEXCOORD_ATTRIBUTE);
//    program->link();
//
//    program->bind();
//    program->setUniformValue("texture", 0);
//}
//
//void GLWidget::paintGL()
//{
//    glClearColor(clearColour.redF(), clearColour.greenF(), clearColour.blueF(), clearColour.alphaF());
//    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//
//    QMatrix4x4 m;
//
//    m.ortho(0.0f, +1.0f, v_aspect, 0.0f, 4.0f, 15.0f);
//    m.translate(0.0f, 0.0f, -5.0f);
//
//    m.rotate(xRot / 16.0f, 1.0f, 0.0f, 0.0f);
//    m.rotate(yRot / 16.0f, 0.0f, 1.0f, 0.0f);
//    m.rotate(zRot / 16.0f, 0.0f, 0.0f, 1.0f);
//
//    program->setUniformValue("matrix", m);
//    program->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
//    program->enableAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE);
//    program->setAttributeBuffer(PROGRAM_VERTEX_ATTRIBUTE, GL_FLOAT, 0, 3, 5 * sizeof(GLfloat));
//    program->setAttributeBuffer(PROGRAM_TEXCOORD_ATTRIBUTE, GL_FLOAT, 3 * sizeof(GLfloat), 2, 5 * sizeof(GLfloat));
//
//    if(hasTexture)
//    {
//    frame_texture->bind();
//    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
//    }
//}
//
//void GLWidget::resizeGL(int width, int height)
//{
//    glViewport(0, 0, width, height);
//}
//
//void GLWidget::mousePressEvent(QMouseEvent *event)
//{
//    lastPos = event->pos();
//}
//
//void GLWidget::mouseMoveEvent(QMouseEvent *event)
//{
//    int dx = event->x() - lastPos.x();
//    int dy = event->y() - lastPos.y();
//
//    if (event->buttons() & Qt::LeftButton) {
//        rotateBy(8 * dy, 8 * dx, 0);
//    } else if (event->buttons() & Qt::RightButton) {
//        rotateBy(8 * dy, 0, 8 * dx);
//    }
//    lastPos = event->pos();
//}
//
//void GLWidget::mouseReleaseEvent(QMouseEvent * /* event */)
//{
//    emit clicked();
//}
//
//void GLWidget::makeObject()
//{
//    static const float coords[4][3] = {
//    { 1.0f, v_aspect, 0.0f },
//    { 0.0f, v_aspect, 0.0f },
//    { 0.0f, 0.0f,     0.0f },
//    { 1.0f, 0.0f,     0.0f }
//    };
//
//    QVector<GLfloat> vertData;
//    for(int j = 0; j < 4; ++j)
//    {
//    // vertex position
//    vertData.append(1.0 * coords[j][0]);
//    vertData.append(1.0 * coords[j][1]);
//    vertData.append(1.0 * coords[j][2]);
//
//    // texture coordinate
//    vertData.append(j == 0 || j == 3);
//    vertData.append(j == 0 || j == 1);
//    }
//
//    vbo.create();
//    vbo.bind();
//    vbo.allocate(vertData.constData(), vertData.count() * sizeof(GLfloat));
//}
// 
//#include "moc_glwidget.cpp"

/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the examples of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** BSD License Usage
** Alternatively, you may use this file under the terms of the BSD license
** as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
**   * Redistributions of source code must retain the above copyright
**     notice, this list of conditions and the following disclaimer.
**   * Redistributions in binary form must reproduce the above copyright
**     notice, this list of conditions and the following disclaimer in
**     the documentation and/or other materials provided with the
**     distribution.
**   * Neither the name of The Qt Company Ltd nor the names of its
**     contributors may be used to endorse or promote products derived
**     from this software without specific prior written permission.
**
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
** $QT_END_LICENSE$
**
****************************************************************************/


#include "glwidget.h"
#include <QOpenGLShaderProgram>
#include <QOpenGLTexture>
#include <QMouseEvent>

GLWidget::GLWidget(QWidget *parent)
	: QOpenGLWidget(parent),
	clearColor(Qt::black),
	xRot(0),
	yRot(0),
	zRot(0),
	program(0)
{
	memset(textures, 0, sizeof(textures));
}

GLWidget::~GLWidget()
{
	makeCurrent();
	vbo.destroy();
	for (int i = 0; i < 6; ++i)
		delete textures[i];
	delete program;
	doneCurrent();
}

QSize GLWidget::minimumSizeHint() const
{
	return QSize(50, 50);
}

QSize GLWidget::sizeHint() const
{
	return QSize(200, 200);
}

void GLWidget::rotateBy(int xAngle, int yAngle, int zAngle)
{
	xRot += xAngle;
	yRot += yAngle;
	zRot += zAngle;
	update();
}

void GLWidget::setClearColor(const QColor &color)
{
	clearColor = color;
	update();
}

void GLWidget::initializeGL()
{
	initializeOpenGLFunctions();

	makeObject();

	glEnable(GL_DEPTH_TEST);
	glEnable(GL_CULL_FACE);

#define PROGRAM_VERTEX_ATTRIBUTE 0
#define PROGRAM_TEXCOORD_ATTRIBUTE 1

	QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
	const char *vsrc =
		"attribute highp vec4 vertex;\n"
		"attribute mediump vec4 texCoord;\n"
		"varying mediump vec4 texc;\n"
		"uniform mediump mat4 matrix;\n"
		"void main(void)\n"
		"{\n"
		"    gl_Position = matrix * vertex;\n"
		"    texc = texCoord;\n"
		"}\n";
	vshader->compileSourceCode(vsrc);

	QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
	const char *fsrc =
		"uniform sampler2D texture;\n"
		"varying mediump vec4 texc;\n"
		"void main(void)\n"
		"{\n"
		"    gl_FragColor = texture2D(texture, texc.st);\n"
		"}\n";
	fshader->compileSourceCode(fsrc);

	program = new QOpenGLShaderProgram;
	program->addShader(vshader);
	program->addShader(fshader);
	program->bindAttributeLocation("vertex", PROGRAM_VERTEX_ATTRIBUTE);
	program->bindAttributeLocation("texCoord", PROGRAM_TEXCOORD_ATTRIBUTE);
	program->link();

	program->bind();
	program->setUniformValue("texture", 0);
}

void GLWidget::paintGL()
{
	glClearColor(clearColor.redF(), clearColor.greenF(), clearColor.blueF(), clearColor.alphaF());
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	QMatrix4x4 m;
	m.ortho(-0.5f, +0.5f, +0.5f, -0.5f, 4.0f, 15.0f);
	m.translate(0.0f, 0.0f, -10.0f);
	m.rotate(xRot / 16.0f, 1.0f, 0.0f, 0.0f);
	m.rotate(yRot / 16.0f, 0.0f, 1.0f, 0.0f);
	m.rotate(zRot / 16.0f, 0.0f, 0.0f, 1.0f);

	program->setUniformValue("matrix", m);
	program->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
	program->enableAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE);
	program->setAttributeBuffer(PROGRAM_VERTEX_ATTRIBUTE, GL_FLOAT, 0, 3, 5 * sizeof(GLfloat));
	program->setAttributeBuffer(PROGRAM_TEXCOORD_ATTRIBUTE, GL_FLOAT, 3 * sizeof(GLfloat), 2, 5 * sizeof(GLfloat));

	for (int i = 0; i < 6; ++i) {
		textures[i]->bind();
		glDrawArrays(GL_TRIANGLE_FAN, i * 4, 4);
	}
}
void GLWidget::resizeGL(int width, int height)
{
	int side = qMin(width, height);
	glViewport((width - side) / 2, (height - side) / 2, side, side);
}

void GLWidget::mousePressEvent(QMouseEvent *event)
{
	lastPos = event->pos();
}

void GLWidget::mouseMoveEvent(QMouseEvent *event)
{
	int dx = event->x() - lastPos.x();
	int dy = event->y() - lastPos.y();

	if (event->buttons() & Qt::LeftButton) {
		rotateBy(8 * dy, 8 * dx, 0);
	} else if (event->buttons() & Qt::RightButton) {
		rotateBy(8 * dy, 0, 8 * dx);
	}
	lastPos = event->pos();
}

void GLWidget::mouseReleaseEvent(QMouseEvent * /* event */)
{
	emit clicked();
}

void GLWidget::makeObject()
{
	static const int coords[6][4][3] = {
		{ { +1, -1, -1 }, { -1, -1, -1 }, { -1, +1, -1 }, { +1, +1, -1 } },
		{ { +1, +1, -1 }, { -1, +1, -1 }, { -1, +1, +1 }, { +1, +1, +1 } },
		{ { +1, -1, +1 }, { +1, -1, -1 }, { +1, +1, -1 }, { +1, +1, +1 } },
		{ { -1, -1, -1 }, { -1, -1, +1 }, { -1, +1, +1 }, { -1, +1, -1 } },
		{ { +1, -1, +1 }, { -1, -1, +1 }, { -1, -1, -1 }, { +1, -1, -1 } },
		{ { -1, -1, +1 }, { +1, -1, +1 }, { +1, +1, +1 }, { -1, +1, +1 } }
	};

	for (int j = 0; j < 6; ++j)
		textures[j] = new QOpenGLTexture(QImage(QString(":/images/side%1.png").arg(j + 1)).mirrored());

	QVector<GLfloat> vertData;
	for (int i = 0; i < 6; ++i) {
		for (int j = 0; j < 4; ++j) {
			// vertex position
			vertData.append(0.2 * coords[i][j][0]);
			vertData.append(0.2 * coords[i][j][1]);
			vertData.append(0.2 * coords[i][j][2]);
			// texture coordinate
			vertData.append(j == 0 || j == 3);
			vertData.append(j == 0 || j == 1);
		}
	}

	vbo.create();
	vbo.bind();
	vbo.allocate(vertData.constData(), vertData.count() * sizeof(GLfloat));
}

#include "moc_glwidget.cpp"